Page({
  data: {
    positionCode: '', // 岗位代码
    querying: false, // 是否正在查询
    queryResult: null, // 查询结果
    maxUniqueCodes: 3, // 最多可查询的不同岗位代码数
    queriedCodes: [] // 已查询过的不同岗位代码（本地存储）
  },

  onLoad(options) {
    // 从上一个页面传递过来的参数
    if (options.courseId) {
      this.setData({
        courseId: options.courseId
      })
    }

    // 从本地存储获取已查询的不同岗位代码
    this.loadQueriedCodes()
  },

  // 从本地存储加载不同岗位代码（最多3个）
  loadQueriedCodes() {
    const cached = wx.getStorageSync('queriedCodes') || []
    this.setData({ queriedCodes: Array.isArray(cached) ? cached : [] })
  },

  // 输入岗位代码
  onPositionCodeInput(e) {
    this.setData({
      positionCode: e.detail.value.trim()
    })
  },

  // 查询岗位保护/同岗报名
  async queryPositionProtection() {
    const { positionCode, queriedCodes, maxUniqueCodes, querying } = this.data

    // 验证岗位代码是否为空
    if (!positionCode) {
      wx.showToast({
        title: '请输入岗位代码',
        icon: 'none',
        duration: 2000
      })
      return
    }

    // 14位数字验证
    if (!/^\d{14}$/.test(positionCode)) {
      wx.showToast({
        title: '岗位代码需为14位数字',
        icon: 'none'
      })
      return
    }

    // 检查是否正在查询
    if (querying) {
      return
    }

    // 检查不同岗位代码查询上限（已存在的不计数）
    if (!queriedCodes.includes(positionCode) && queriedCodes.length >= maxUniqueCodes) {
      wx.showToast({
        title: '您已超过查询次数上限',
        icon: 'none'
      })
      return
    }

    // 开始查询
    this.setData({
      querying: true
    })

    wx.showLoading({
      title: '查询中...',
      mask: true
    })

    try {
      // 先做黑名单校验
      const isBlack = await this.checkBlacklist()
      if (isBlack) {
        wx.hideLoading()
        this.navigateToFail('您当前不可报名')
        return
      }

      // 调用查询接口
      const result = await this.callQueryAPI(positionCode)

      // 缓存不同岗位代码（新代码才加入）
      if (!queriedCodes.includes(positionCode)) {
        const updated = [...queriedCodes, positionCode]
        wx.setStorageSync('queriedCodes', updated)
        this.setData({ queriedCodes: updated })
      }

      this.setData({ queryResult: result })

      wx.hideLoading()

      // 处理查询结果
      this.handleQueryResult(result)

    } catch (error) {
      wx.hideLoading()
      wx.showToast({
        title: error.message || '查询失败，请稍后重试',
        icon: 'none',
        duration: 2000
      })
    } finally {
      this.setData({
        querying: false
      })
    }
  },

  // 黑名单校验
  checkBlacklist() {
    return new Promise((resolve) => {
      const api = 'https://your-api.com/api/blacklist/check'
      const phone = wx.getStorageSync('phone') || ''
      if (!phone) {
        // 未保存手机号的情况默认非黑名单
        resolve(false)
        return
      }
      wx.request({
        url: api,
        method: 'GET',
        data: { phone },
        success: (res) => {
          const black = res.statusCode === 200 && (res.data.blacklisted || res.data.isBlack)
          resolve(!!black)
        },
        fail: () => resolve(false)
      })
    })
  },

  // 调用查询接口
  callQueryAPI(positionCode) {
    return new Promise((resolve, reject) => {
      // 这里替换为你的实际接口地址
      const apiUrl = 'https://your-api.com/api/position/query'

      wx.request({
        url: apiUrl,
        method: 'POST',
        data: {
          positionCode: positionCode,
          phone: wx.getStorageSync('phone') || '', // 从本地存储获取手机号
          courseId: this.data.courseId || ''
        },
        header: {
          'content-type': 'application/json'
        },
        success: (res) => {
          if (res.statusCode === 200) {
            if (res.data.code === 0 || res.data.success) {
              // 查询成功
              resolve(res.data.data || res.data)
            } else {
              // 接口返回错误
              reject(new Error(res.data.message || '查询失败'))
            }
          } else {
            reject(new Error('网络请求失败'))
          }
        },
        fail: (err) => {
          // 网络错误，使用模拟数据
          console.log('接口调用失败，使用模拟数据:', err)
          // 模拟接口返回
          setTimeout(() => {
            const mockData = {
              hasSamePosition: Math.random() > 0.5,
              paid: Math.random() > 0.5,
              message: '模拟查询结果'
            }
            resolve(mockData)
          }, 1000)
        }
      })
    })
  },

  // 处理查询结果
  handleQueryResult(result) {
    const { positionCode, queriedCodes, maxUniqueCodes } = this.data
    const remaining = Math.max(0, maxUniqueCodes - queriedCodes.length)

    // 有同岗报名且已缴费 -> 报名失败页
    if (result.hasSamePosition && result.paid) {
      this.navigateToFail('检测到同岗位已报名且已缴费')
      return
    }

    // 无同岗报名 -> 弹出提示并跳转报名须知
    if (!result.hasSamePosition) {
      wx.showModal({
        title: '提示',
        content: '当前暂无同岗报名，请点击阅读报名须知',
        confirmText: '阅读报名须知',
        showCancel: false,
        success: () => {
          const courseId = this.data.courseId || ''
          const positionCode = this.data.positionCode || ''
          wx.navigateTo({
            url: `/pages/notice/index?courseId=${courseId}&positionCode=${positionCode}`
          })
        }
      })
      return
    }

    // 有同岗但未缴费 -> 仅提示
    if (result.hasSamePosition && !result.paid) {
      wx.showToast({ title: '有同岗报名（未缴费）', icon: 'none' })
      return
    }
  },

  // 跳转报名失败状态页
  navigateToFail(reason) {
    wx.navigateTo({
      url: `/pages/result/apply-failed/index?reason=${encodeURIComponent(reason || '')}`
    })
  },

  // 清空输入
  clearInput() {
    this.setData({
      positionCode: ''
    })
  }
})
